// API调用工具类
const apiConfig = require('../config/api-config.js')
const BASE_URL = apiConfig.other.backendUrl // 后端服务地址

// 检查后端服务是否可用
async function checkBackendHealth() {
  try {
    const res = await new Promise((resolve, reject) => {
      wx.request({
        url: BASE_URL + '/health',
        method: 'GET',
        timeout: 3000,
        success: resolve,
        fail: reject
      })
    })
    return res.statusCode === 200
  } catch (error) {
    console.warn('后端服务不可用:', error)
    return false
  }
}


/**
 * 封装微信小程序的网络请求
 */
function request(options) {
  return new Promise((resolve, reject) => {
    wx.request({
      url: BASE_URL + options.url,
      method: options.method || 'GET',
      data: options.data || {},
      header: {
        'Content-Type': 'application/json',
        ...options.header
      },
      timeout: options.timeout || 10000,
      success: (res) => {
        if (res.statusCode === 200) {
          resolve(res.data)
        } else {
          reject(new Error(`请求失败: ${res.statusCode} - ${res.data?.message || '未知错误'}`))
        }
      },
      fail: (err) => {
        console.error('网络请求失败:', err)
        reject(new Error(`网络请求失败: ${err.errMsg || '连接超时'}`))
      }
    })
  })
}

/**
 * 分类相关API
 */
const categoryApi = {
  // 获取所有分类
  getCategories() {
    return request({
      url: '/category/getCategory',
      method: 'GET'
    })
  },

  // 根据类型获取分类
  getCategoriesByType(type) {
    return request({
      url: `/category/getCategory?type=${type}`,
      method: 'GET'
    })
  },

  // 获取分类树
  getCategoryTree(type) {
    return request({
      url: `/category/getCategory?type=${type}`,
      method: 'GET'
    })
  },

  // 根据父分类获取子分类
  getCategoriesByParentId(parentId) {
    return request({
      url: `/category/getCategory?parentId=${parentId}`,
      method: 'GET'
    })
  },

  // 获取分类详情
  getCategoryById(id) {
    return request({
      url: `/category/getCategory?id=${id}`,
      method: 'GET'
    })
  }
}

/**
 * 课程相关API
 */
const contentApi = {
  // 获取所有课程
  getContents() {
    return request({
      url: '/contentChapter/getCont',
      method: 'GET'
    })
  },

  // 根据分类获取课程
  getContentsByCategory(categoryId) {
    return request({
      url: `/contentChapter/getCont?categoryId=${categoryId}`,
      method: 'GET'
    })
  },

  // 分页获取课程
  getContentsByPage(page = 1, size = 10, categoryId = null, type = null) {
    let url = `/contentChapter/getCont?page=${page}&size=${size}`
    if (categoryId) {
      url += `&categoryId=${categoryId}`
    }
    if (type) {
      url += `&type=${type}`
    }
    return request({
      url: url,
      method: 'GET'
    })
  },

  // 获取热门课程
  getHotContents(limit = 10) {
    return request({
      url: `/contentChapter/getCont?limit=${limit}&hot=true`,
      method: 'GET'
    })
  },

  // 获取免费课程
  getFreeContents(limit = 10) {
    return request({
      url: `/contentChapter/getCont?limit=${limit}&free=true`,
      method: 'GET'
    })
  },

  // 获取课程详情
  getContentById(id) {
    return request({
      url: `/contentChapter/getCont1?id=${id}`,
      method: 'GET'
    })
  }
}

/**
 * VIP套餐相关API
 */
const vipApi = {
  // 获取所有VIP套餐
  getVipPackages() {
    return request({
      url: '/viporder/viptaocanAll',
      method: 'GET'
    })
  },

  // 购买VIP套餐
  purchaseVipPackage(packageId) {
    return request({
      url: '/viporder/purchase',
      method: 'POST',
      data: {
        packageId: packageId
      }
    })
  }
}

/**
 * 阿里云舌面诊API配置
 */
const ALIBABA_API_CONFIG = apiConfig.alibabaTongueFaceApi

/**
 * MD5加密函数
 */
function md5(str) {
  // 微信小程序环境下的MD5实现
  const crypto = require('crypto-js')
  return crypto.MD5(str).toString().toUpperCase()
}

/**
 * 生成时间戳
 */
function generateTimestamp() {
  const now = new Date()
  const year = now.getFullYear()
  const month = String(now.getMonth() + 1).padStart(2, '0')
  const day = String(now.getDate()).padStart(2, '0')
  const hours = String(now.getHours()).padStart(2, '0')
  const minutes = String(now.getMinutes()).padStart(2, '0')
  const seconds = String(now.getSeconds()).padStart(2, '0')
  return `${year}${month}${day}${hours}${minutes}${seconds}`
}

/**
 * 生成签名
 */
function generateSign(timestamp, key) {
  const firstMd5 = md5(timestamp)
  const secondMd5 = md5(firstMd5 + key)
  return secondMd5
}

/**
 * AI相关API
 */
const aiApi = {
  // 直接使用本地图片路径，不再上传到MinIO
  uploadFaceImage(imagePath) {
    return new Promise((resolve) => {
      console.log('使用本地图片路径:', imagePath)
      
      // 直接返回本地图片路径
      resolve({
        code: 200,
        message: '使用本地图片',
        data: {
          imageUrl: imagePath, // 直接使用本地临时文件路径
          fileName: imagePath.substring(imagePath.lastIndexOf('/') + 1)
        }
      })
    })
  },

  // 调用阿里云舌面诊API（将本地图片转为base64编码）
  analyzeFaceTongue(faceImagePath, tongueImagePath = null, sublingualImagePath = null, gender = null) {
    return new Promise((resolve, reject) => {
      // 检查是否是本地文件路径
      const isLocalPath = (path) => path && (path.startsWith('wxfile://') || path.startsWith('http://tmp/') || path.startsWith('https://tmp/'));
      
      // 将本地图片转为base64的函数
      const fileToBase64 = (filePath) => {
        return new Promise((resolve, reject) => {
          // 检查文件扩展名，确保是支持的图片格式
          const supportedFormats = ['.jpg', '.jpeg', '.png', '.bmp'];
          const fileExt = filePath.substring(filePath.lastIndexOf('.')).toLowerCase();
          const isSupported = supportedFormats.some(ext => fileExt.includes(ext));
          
          if (!isSupported) {
            console.warn(`文件格式可能不受支持: ${fileExt}，支持的格式: ${supportedFormats.join(', ')}`);
            // 继续处理，因为临时文件可能没有正确的扩展名
          }
          
          wx.getFileSystemManager().readFile({
            filePath: filePath,
            encoding: 'base64',
            success: res => {
              if (!res.data || typeof res.data !== 'string' || res.data.length === 0) {
                console.error('读取文件成功但数据为空');
                reject(new Error('Base64数据为空'));
                return;
              }
              
              console.log(`成功读取文件并转换为base64，数据长度: ${res.data.length}`);
              resolve(res.data);
            },
            fail: err => {
              console.error('读取文件失败:', err);
              reject(err);
            }
          });
        });
      };
      
      // 处理所有图片，转换为base64或保留URL
      const processImages = async () => {
        try {
          // 准备请求数据
          const requestData = {
            scene: 2 // 固定值2
          };
          
          // 处理面部图片
          if (faceImagePath) {
            if (isLocalPath(faceImagePath)) {
              // 如果是本地文件路径，转为base64
              const base64Data = await fileToBase64(faceImagePath);
              // 直接使用base64数据，不添加前缀
              requestData.ff_image = base64Data;
            } else {
              // 如果是URL，直接使用
              requestData.ff_image = faceImagePath;
            }
          }
          
          // 处理舌部图片
          if (tongueImagePath) {
            if (isLocalPath(tongueImagePath)) {
              // 如果是本地文件路径，转为base64
              const base64Data = await fileToBase64(tongueImagePath);
              // 直接使用base64数据，不添加前缀
              requestData.tf_image = base64Data;
            } else {
              // 如果是URL，直接使用
              requestData.tf_image = tongueImagePath;
            }
          }
          
          // 处理舌下脉络图片
          if (sublingualImagePath) {
            if (isLocalPath(sublingualImagePath)) {
              // 如果是本地文件路径，转为base64
              const base64Data = await fileToBase64(sublingualImagePath);
              // 直接使用base64数据，不添加前缀
              requestData.tb_image = base64Data;
            } else {
              // 如果是URL，直接使用
              requestData.tb_image = sublingualImagePath;
            }
          }
          
          // 添加性别信息（如果有）
          if (gender) {
            requestData.gender = gender;
          }
          
          console.log('调用阿里云舌面诊API:', '使用base64编码图片');
          
          // 添加详细日志，检查请求数据（不打印完整base64数据，避免日志过长）
          const logRequestData = {...requestData};
          if (logRequestData.ff_image && typeof logRequestData.ff_image === 'string') {
            logRequestData.ff_image = `[Base64 String, length: ${logRequestData.ff_image.length}]`;
          }
          if (logRequestData.tf_image && typeof logRequestData.tf_image === 'string') {
            logRequestData.tf_image = `[Base64 String, length: ${logRequestData.tf_image.length}]`;
          }
          if (logRequestData.tb_image && typeof logRequestData.tb_image === 'string') {
            logRequestData.tb_image = `[Base64 String, length: ${logRequestData.tb_image.length}]`;
          }
          console.log('请求数据:', JSON.stringify(logRequestData));
          
          // 发送请求
          wx.request({
            url: ALIBABA_API_CONFIG.baseUrl,
            method: 'POST',
            data: requestData,
            header: {
              'Content-Type': 'application/json',
              'Authorization': `APPCODE ${ALIBABA_API_CONFIG.appCode}`
            },
            success: (res) => {
              console.log('阿里云舌面诊API响应状态码:', res.statusCode);
              try {
                console.log('阿里云舌面诊API原始数据类型:', typeof res.data);
                if (typeof res.data === 'string' && res.data.length > 200) {
                  console.log('阿里云舌面诊API原始数据内容(前200字符):', res.data.slice(0, 200));
                } else {
                  console.log('阿里云舌面诊API原始数据:', res.data);
                }
              } catch (e) {
                console.warn('打印原始数据失败:', e);
              }
              
              if (res.statusCode === 200) {
                // 兼容服务端返回字符串的情况
                let data = res.data;
                if (typeof data === 'string') {
                  try {
                    data = JSON.parse(data);
                  } catch (e) {
                    console.warn('API返回为字符串且无法解析为JSON:', data);
                    data = null;
                  }
                }

                if (data && typeof data === 'object') {
                  resolve(data);
                } else {
                  console.warn('API响应数据无效，使用模拟结果:', data);
                  reject(new Error('API响应数据无效'));
                }
              } else {
                console.error('API请求失败，状态码:', res.statusCode, '响应数据:', res.data);
                reject(new Error(`请求失败: ${res.statusCode}`));
              }
            },
            fail: (err) => {
              console.error('阿里云舌面诊API请求失败:', err);
              reject(err);
            }
          });
        } catch (error) {
          console.error('处理图片失败:', error);
          reject(error);
        }
      };
      
      // 开始处理图片并发送请求
      processImages().catch(error => {
        console.error('处理图片或发送请求失败:', error);
        reject(error);
      });
    }).catch(error => {
      console.warn('阿里云舌面诊API调用失败，使用模拟结果:', error);
      // 返回模拟分析结果
      return {
        code: 20000,
        success: true,
        msg: '成功',
        data: {
          score: 85,
          features: [
            {
              feature_category: '面部',
              feature_group: '面色',
              feature_name: '面色红',
              feature_situation: '异常',
              feature_interpret: '面色较正常偏红。主要因为体内热重,引起血液循环加速,血液充盈面部表现出面色红的现象。'
            },
            {
              feature_category: '舌部',
              feature_group: '舌色',
              feature_name: '舌色淡白',
              feature_situation: '异常',
              feature_interpret: '舌色比正常舌色浅淡,偏白,因舌体肌肉血流量不足导致。多见于气血不足或者阳虚的群体。'
            }
          ],
          physique_name: '气虚体质',
          physique_analysis: '气虚体质是指由于元气不足，以疲乏、气短、自汗等气虚表现为主要特征的体质状态。',
          typical_symptom: '容易疲乏，气短，自汗，易感冒',
          risk_warning: '容易感冒，内脏下垂，慢性疲劳综合征',
          syndrome_name: '气虚证',
          syndrome_introduction: '气虚证是指由于元气不足，气的推动、温煦、固摄、防御、气化等功能减退，或脏腑组织的机能活动减退所表现的证候。',
          advices: {
            food: [
              {
                title: '补气食物',
                advice: '多食用山药、大枣、蜂蜜、鸡肉、牛肉等补气食物'
              }
            ],
            sport: [
              {
                title: '适量运动',
                advice: '选择太极拳、八段锦等柔和的运动方式，避免过度劳累'
              }
            ]
          }
        }
      };
    });
  },

  // 兼容旧版本的面诊API调用
  analyzeFace(imageUrl) {
    return this.analyzeFaceTongue(imageUrl)
  },
  
  // 舌诊API调用
  analyzeTongue(faceImagePath, tongueImagePath, sublingualImagePath = null) {
    return this.analyzeFaceTongue(faceImagePath, tongueImagePath, sublingualImagePath)
  },

  // AI聊天
  chatWithAI(message) {
    return request({
      url: '/ai/chat',
      method: 'POST',
      data: {
        message: message
      }
    }).catch(error => {
      console.warn('AI聊天接口调用失败，使用模拟回复:', error)
      // 返回模拟回复
      return {
        code: 200,
        message: '回复成功（模拟）',
        data: {
          reply: '感谢您的咨询。作为AI中医助手，我建议您详细描述症状，以便提供更准确的建议。请注意，我的建议仅供参考，如有不适请及时就医。'
        }
      }
    })
  }
}

/**
 * 登录相关API
 */
const loginApi = {
  // 发送验证码
  async sendCode(phoneNumber) {
    try {
      // 先检查后端服务是否可用
      const isBackendAvailable = await checkBackendHealth()
      
      if (!isBackendAvailable) {
        // 后端不可用，返回模拟成功响应
        console.warn('后端服务不可用，使用模拟验证码')
        return new Promise((resolve) => {
          setTimeout(() => {
            resolve({
              code: 200,
              message: '验证码已发送（模拟）',
              data: {
                code: '123456' // 模拟验证码
              }
            })
          }, 1000)
        })
      }
      
      // 后端可用，正常请求
      return request({
        url: '/login/sendCode',
        method: 'POST',
        data: {
          phoneNumber: phoneNumber
        }
      })
    } catch (error) {
      console.warn('发送验证码失败，使用模拟模式:', error)
      // 请求失败时也返回模拟成功响应
      return {
        code: 200,
        message: '验证码已发送（模拟）',
        data: {
          code: '123456'
        }
      }
    }
  },

  // 验证码登录
  async verifyCode(phoneNumber, code) {
    try {
      // 先检查后端服务是否可用
      const isBackendAvailable = await checkBackendHealth()
      
      if (!isBackendAvailable) {
        // 后端不可用，使用模拟登录
        console.warn('后端服务不可用，使用模拟登录')
        return new Promise((resolve) => {
          setTimeout(() => {
            resolve({
              code: 200,
              message: '登录成功（模拟）',
              data: {
                token: 'mock_token_' + Date.now(),
                userInfo: {
                  id: 1,
                  phone: phoneNumber,
                  nickname: '测试用户',
                  avatar: '/images/avatar.svg',
                  isLogin: true,
                  loginTime: new Date().getTime()
                }
              }
            })
          }, 1500)
        })
      }
      
      // 后端可用，正常请求
      return request({
        url: '/login/verifyCode',
        method: 'POST',
        data: {
          phoneNumber: phoneNumber,
          code: code
        }
      })
    } catch (error) {
      console.warn('验证码登录失败，使用模拟模式:', error)
      // 请求失败时也返回模拟成功响应
      return {
        code: 200,
        message: '登录成功（模拟）',
        data: {
          token: 'mock_token_' + Date.now(),
          userInfo: {
            id: 1,
            phone: phoneNumber,
            nickname: '测试用户',
            avatar: '/images/avatar.svg',
            isLogin: true,
            loginTime: new Date().getTime()
          }
        }
      }
    }
  },

  // 用户名密码登录
  async loginByPassword(username, password) {
    try {
      // 先检查后端服务是否可用
      const isBackendAvailable = await checkBackendHealth()
      
      if (!isBackendAvailable) {
        // 后端不可用，使用模拟登录
        console.warn('后端服务不可用，使用模拟登录')
        return new Promise((resolve) => {
          setTimeout(() => {
            resolve({
              code: 200,
              message: '登录成功（模拟）',
              data: {
                token: 'mock_token_' + Date.now(),
                userInfo: {
                  id: 5,
                  username: username,
                  phone: '13052651019',
                  nickname: '微信用户JIG4r',
                  avatar: 'http://39.1',
                  isLogin: true,
                  loginTime: new Date().getTime(),
                  loginType: 'wechat'
                }
              }
            })
          }, 1500)
        })
      }
      
      // 后端可用，正常请求
      return request({
        url: '/login/loginByPassword',
        method: 'POST',
        data: {
          username: username,
          password: password
        }
      })
    } catch (error) {
      console.warn('用户名密码登录失败，使用模拟模式:', error)
      // 请求失败时也返回模拟成功响应
      return {
        code: 200,
        message: '登录成功（模拟）',
        data: {
          token: 'mock_token_' + Date.now(),
          userInfo: {
            id: 5,
            username: username,
            phone: '13052651019',
            nickname: '微信用户JIG4r',
            avatar: 'http://39.1',
            isLogin: true,
            loginTime: new Date().getTime(),
            loginType: 'wechat'
          }
        }
      }
    }
  },

  // 验证token
  validateToken(token) {
    return request({
      url: '/login/validateToken',
      method: 'POST',
      data: {
        token: token
      }
    })
  }
}


module.exports = {
  request,
  categoryApi,
  contentApi,
  vipApi,
  aiApi,
  loginApi
}
